package com.hangwei.paperless.net;

import android.text.TextUtils;
import android.util.Log;

import com.hangwei.paperless.model.entity.TokenReset;
import com.twelve.all.manager.RXManager;
import com.twelve.all.manager.Retrofit2Manager;
import com.twelve.all.net.CallBack;
import com.twelve.all.net.MySubscriber;
import com.twelve.all.net.ResponseInfo;
import com.twelve.all.utils.LogUtil;
import com.twelve.all.utils.ToastUtil;
import com.umeng.umcrash.UMCrash;

import org.greenrobot.eventbus.EventBus;

import rx.Observable;
import rx.Subscription;


/**
 * author: 张龙臣
 * date: 2018-08-13.
 */

public class NetManager {
    private static NetManager instance;
    private static ResponseInfoAPI mResponseInfoAPI;

    private NetManager() {
    }

    public static ResponseInfoAPI getResponseInfoAPI() {
        if (mResponseInfoAPI == null) {
            synchronized (NetManager.class) {
                if (mResponseInfoAPI == null) {
                    mResponseInfoAPI = Retrofit2Manager.getInstance().create(ResponseInfoAPI.class);
                }
            }
        }
        return mResponseInfoAPI;
    }

    public static NetManager getInstance() {
        if (instance == null) {
            synchronized (NetManager.class) {
                if (instance == null) {
                    instance = new NetManager();
                }
            }
        }
        return instance;
    }

    public <T> Subscription doSubscribe(Model<T> model) {
        return model.execute();
    }
//    public <T> Subscription doSubscribe(SerialModel<T> model) {
//        return model.executeSerial();
//    }

    public abstract static class Model<T> {

        private CallBack<T> callBack;

        protected Model(CallBack<T> callBack) {
            this.callBack = callBack;
        }

//        protected Model() {
//        }

        private Subscription execute() {

            return RXManager.getInstance().doSubscribe(getObservable(), new MySubscriber<ResponseInfo<T>>() {
                @Override
                public void onNext(ResponseInfo<T> tResponseInfo) {
                    super.onNext(tResponseInfo);
                    if (tResponseInfo.code == 0) {
                        LogUtil.d("解析成功 格式正确 code == 0 数据正常 !");
                        if (callBack != null)
                            callBack.onCompleted(tResponseInfo.data);
                    } else if (tResponseInfo.code == -2) {
                        EventBus.getDefault().post(new TokenReset());
                    } else {
                        //返回数据格式正确,但flag显示不是正确想要的数据(一般msg中会给出错误情况)
                        LogUtil.e("解析成功 格式正确 code != 0 无正常数据 !   ------------");
                        Model.this.onError(tResponseInfo.msg, tResponseInfo.code);
                        UMCrash.generateCustomLog(tResponseInfo.msg, "ResolveException");
                    }
                }

                @Override
                public void onError(Throwable e) {
                    super.onError(e);//直接请求错误,根本没有拿到 ResponseInfo<T> 格式数据, 基本断定为网络错误或解析格式错误
                    Model.this.onError(null, -1);
                    UMCrash.generateCustomLog(e, "UrlException");
                }
            });
        }

        protected abstract Observable<ResponseInfo<T>> getObservable();

        /**
         * 针对具体的code进行处理
         */
        private void onError(String msg, int code) {
            Log.e(this.getClass().getName(), msg == null ? "网络错误0" : msg);
            switch (code) {
                case -1:
                default:
                    ToastUtil.showToast(TextUtils.isEmpty(msg) ? "网络错误0" : msg);
                    break;
            }
            if (callBack != null)
                callBack.onError();
        }
    }

//    /**
//     * Rx 串行请求使用
//     */
//    public abstract class SerialModel<T> {
//
//
//        private Subscription executeSerial(){
//            return  Observable.merge(getObservableList()).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread())
//                    .subscribe(new MySubscriber<ResponseInfo<T>>(){
//                        @Override
//                        public void onNext(ResponseInfo<T> tResponseInfo) {
//                            super.onNext(tResponseInfo);
//                            if (tResponseInfo.code == 0) {
//                                LogUtil.d("解析成功 格式正确 code == 0 数据正常 !");
//
//                            } else {
//                                //返回数据格式正确,但flag显示不是正确想要的数据(一般msg中会给出错误情况)
//                                LogUtil.e("解析成功 格式正确 code != 0 无正常数据 !   ------------");
//
//                            }
//                        }
//
//                        @Override
//                        public void onError(Throwable e) {
//                            super.onError(e);
//                        }
//
//                        @Override
//                        public void onCompleted() {
//                            super.onCompleted();
//                        }
//                    });
//        }
//
//        protected abstract ArrayList<Observable<ResponseInfo<T>>> getObservableList();
//
//    }
}
